package smlab.view.ui.scroll
{
	import flash.display.DisplayObject;
	import flash.display.DisplayObjectContainer;
	import flash.display.InteractiveObject;
	import flash.display.MovieClip;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.geom.Rectangle;
	import flash.utils.clearTimeout;
	import flash.utils.setTimeout;

	/**
	 * 滚动面板组件
	 * 
	 * 支持以下特性：
	 * 默认皮肤/自定义外部皮肤
	 * 鼠标滚轮
	 * 点击按钮滚动/自动滚动
	 * 点击滑轨滚动/自动滚动
	 * 可实时设置 ScrollPane 的宽高（内容和面板不变形）
	 * 设置自动/强制显示、隐藏滚动条
	 * 设置每次滚动距离
	 * @author simon 2010.1.20-18:30
	 *
	 */
	public class ScrollPane_SM extends Sprite
	{
		/**
		 * 滚动条显示模式：自动/总是隐藏/总是显示
		 */
		public static const SCROLLBAR_SHOW_MODE_AUTO:String="ScrollBar_Show_Mode_auto";
		public static const SCROLLBAR_SHOW_MODE_HIDE:String="ScrollBar_Show_Mode_hide";
		public static const SCROLLBAR_SHOW_MODE_SHOW:String="ScrollBar_Show_Mode_show";

		/**
		 * 滚动目标
		 */
		private var _target:DisplayObject;

		/**
		 * 滚动目标的容器
		 */
		private var _targetContainer:Sprite;
		
		/**
		 * 垂直滚动条皮肤（外部定制）
		 * 
		 * 需要包含以下实例名的 children ：
		 * 上滚按钮：_scrollBarVSkin.upBtn(Sprite)
		 * 下滚按钮：_scrollBarVSkin.downBtn(Sprite)
		 * 滑轨：	   _scrollBarVSkin.trackV（(Sprite)欲实现 scale9Grid 请直接对该实例实现 scale9Grid）
		 * 拖动按钮：_scrollBarVSkin.dragBtnV(Sprite)
		 * 		   （欲实现按钮的 scale9Grid 请对_scrollBarVSkin.dragBtnV.bg 实例实现 scale9Grid，这个 bg 实例可以是任何可实现 scale9Grid 的显示对象；
		 * 		   欲在按钮之上放置不变形图标则实例名应为： _scrollBarVSkin.dragBtnV.icon ，这个 icon 实例可以是任何显示对象；
		 * 		   它会自动居中且不会随 dragBtnV 变形而变形）
		 */
		private var _scrollBarVSkin:MovieClip;

		/**
		 * 垂直滚动条显示模式
		 */
		private var _VScrollBarShowMode:String=SCROLLBAR_SHOW_MODE_AUTO;

		/**
		 * 垂直滚动条滑轨
		 */
		private var _trackV:InteractiveObject;

		/**
		 * 上滚按钮
		 */
		private var _upBtn:InteractiveObject;

		/**
		 * 下滚按钮
		 */
		private var _downBtn:InteractiveObject;

		/**
		 * 垂直拖动条
		 */
		private var _dragBtnV:InteractiveObject;

		/**
		 * 垂直拖动条的最小/最大高度
		 */
		private var _dragBtnVMin:Number=20;
		private var _dragBtnVMax:Number;

		/**
		 * scrollPane 的宽度
		 */
		private var _w:Number;

		/**
		 * scrollPane 的高度
		 */
		private var _h:Number;

		/**
		 * 点击“垂直滚动按钮”时每次滚动多少像素
		 */
		private var _rollNumV:Number=5;

		/**
		 * 当前是采用默认皮肤还是外部皮肤
		 */
		private var _isDefaultSkin:Boolean=true;

		/**
		 * 辅助（鼠标按下时自动滚动）
		 */
		private var _autoRollIntervalID:uint;

		/**
		 * 压下按钮后多少秒开始自动滚动
		 */
		private var _autoRollTime:int=400;

		/**
		 * 鼠标 down 时自动滚动的数值（垂直方向）
		 */
		private var _autoRollNumV:Number=8;
		
		private var _trackVHMin:Number=5;//垂直滚动条最小高度限制
		
		public var scrollVWidth:Number=10;//默认垂直滚动条宽度
		public var scrollVBtnHeight:Number=10;//默认垂直滚动条按钮宽高
		public var scrollVBtnColor:uint=0x999999;//默认垂直滚动条上下按钮颜色
		public var scrollVBarColor:uint=0x666666;//默认垂直滚动条滑动按钮颜色
		public var scrollVTrackColor:uint=0xcccccc;//默认垂直滚动条滑轨颜色

		/**
		 * 构造函数
		 * 
		 * @param target			被滚动的显示对象
		 * @param w					滚动面板宽度（若传负值会自动转成正值）
		 * @param h					滚动面板高度（若传负值才会自动转成正值）
		 * @param rollNumV			每次滚动距离（垂直方向）单位：像素
		 * @param $scrollBarVSkin	垂直滚动条皮肤（若传 null 会自动生成一套“朴素”的默认皮肤）,滚动条元件的要求请查看“_scrollBarVSkin”这个变量的说明
		 *
		 */
		public function ScrollPane_SM(target:DisplayObject, w:Number=100, h:Number=100, $rollNumV:Number=10, $scrollBarVSkin:MovieClip=null)
		{
			super();
			
			_scrollBarVSkin=$scrollBarVSkin;
			_w=Math.abs(w);
			_h=Math.abs(h);
			rollNumV=$rollNumV;
			_target=target;

			initialize();
			doChange();
		}
		
		/**
		 * 给 ScrollPane_SM 重新赋值一个被包含的显示对象
		 * @param target
		 * 
		 */
		public function setTarget(target:DisplayObject):void
		{
			removeTarget();
			_target=target;
			_targetContainer.addChild(_target);
			doChange();
		}

		private function initialize():void
		{
			_targetContainer=new Sprite;
			_targetContainer.focusRect=false;
			_targetContainer.addEventListener(MouseEvent.CLICK,onTargetContainerClick);
			addChild(_targetContainer);
			var r:Rectangle=new Rectangle(0, 0, _w, _h);
			_targetContainer.scrollRect=r;
			_targetContainer.addChild(_target);

			/**
			 * 默认皮肤
			 */
			if (_scrollBarVSkin == null)
			{
				_scrollBarVSkin=new MovieClip;

				var s1:Sprite=new Sprite;
				s1.graphics.beginFill(scrollVTrackColor);
				s1.graphics.drawRect(0, 0, scrollVWidth, _h);
				_scrollBarVSkin.addChild(s1);
				trackV=s1;

				var s2:Sprite=new Sprite;
				s2.graphics.beginFill(scrollVBtnColor);
				s2.graphics.drawRect(0, 0, scrollVWidth, scrollVBtnHeight);
				_scrollBarVSkin.addChild(s2);
				s2.buttonMode=true;
				upBtn=s2;

				var s3:Sprite=new Sprite;
				s3.graphics.beginFill(scrollVBtnColor);
				s3.graphics.drawRect(0, 0, scrollVWidth, scrollVBtnHeight);
				_scrollBarVSkin.addChild(s3);
				s3.y=_h - s3.height;
				s3.buttonMode=true;
				downBtn=s3;

				var s4:Sprite=new Sprite;
				s4.graphics.beginFill(scrollVBarColor);
				s4.graphics.drawRect(0, 0, scrollVWidth, scrollVBtnHeight);
				_scrollBarVSkin.addChild(s4);
				s4.y=trackV.height / 2 - s4.height / 2;
				s4.buttonMode=true;
				dragBtnV=s4;
				
				_isDefaultSkin=true;
			}
			else
			{
				trackV=_scrollBarVSkin.trackV;
				trackV.height=_h;
				upBtn=_scrollBarVSkin.upBtn;
				downBtn=_scrollBarVSkin.downBtn;
				dragBtnV=_scrollBarVSkin.dragBtnV;
				
				_isDefaultSkin=false;
			}
			
			_scrollBarVSkin.x = _w - _scrollBarVSkin.width;
			addChild(_scrollBarVSkin);
			this.addEventListener(Event.ADDED_TO_STAGE, onAddToStage);
			this.addEventListener(Event.REMOVED_FROM_STAGE, onRemoveFromStage);
		}

		/**
		 * 实现可以实时设置 ScrollPane 的宽高（这里设置的宽高是包含滚动条宽高的）
		 * @param value
		 *
		 */
		override public function set width(value:Number):void
		{
			_w=Math.abs(value);
			
			if(stage){//辅助实现鼠标滚轮滚动
				stage.focus=stage;
			}
			
			var r:Rectangle=new Rectangle(0, 0, _w, _h);
			_targetContainer.scrollRect=r;
			_scrollBarVSkin.x=_w - _scrollBarVSkin.width;
			
			removeAutoRollTimeOut();
			stopDragV(null);
			
			doChange();
		}

		override public function set height(value:Number):void
		{
			_h=Math.abs(value);
			
			if(stage){//辅助实现鼠标滚轮滚动
				stage.focus=stage;
			}
			
			var r:Rectangle=new Rectangle(0, 0, _w, _h);
			_targetContainer.scrollRect=r;
			trackV.height=_h;
			downBtn.y=_h - downBtn.height;
			
			if(_target.height+_target.y<_h){
				_target.y=_h-_target.height;
			}
			
			removeAutoRollTimeOut();
			stopDragV(null);
			
			doChange();
		}

		/**
		 * 滑轨
		 * 
		 * 如果希望可以进行不变形拉伸，请将 mc 直接设置 scale9Grid 范围
		 * @param mc
		 *
		 */
		public function set trackV(mc:InteractiveObject):void
		{
			_trackV=mc;
			_trackV.y=0;
//			_trackV.x=_w-_trackV.width;
			_trackV.focusRect=false;
			_trackV.addEventListener(MouseEvent.CLICK, trackMouseHandler);
			_trackV.addEventListener(MouseEvent.MOUSE_DOWN, trackMouseHandler);
			_trackV.addEventListener(MouseEvent.MOUSE_UP, trackMouseHandler);
			_trackV.addEventListener(MouseEvent.MOUSE_OUT, trackMouseHandler);
		}

		public function get trackV():InteractiveObject
		{
			return _trackV;
		}

		/**
		 * 往上滚按钮
		 * @param mc
		 *
		 */
		public function set upBtn(mc:InteractiveObject):void
		{
			_upBtn=mc;
			_upBtn.y=0;
//			_upBtn.x=_w-_upBtn.width;
			_upBtn.addEventListener(MouseEvent.CLICK, btnMouseHandler);
			_upBtn.addEventListener(MouseEvent.MOUSE_DOWN, btnMouseHandler);
			_upBtn.addEventListener(MouseEvent.MOUSE_UP, btnMouseHandler);
			_upBtn.addEventListener(MouseEvent.MOUSE_OUT, btnMouseHandler);
		}

		public function get upBtn():InteractiveObject
		{
			return _upBtn;
		}

		/**
		 * 往下滚按钮
		 * @param mc
		 *
		 */
		public function set downBtn(mc:InteractiveObject):void
		{
			_downBtn=mc;
			_downBtn.y=_h-_downBtn.height;
//			_downBtn.x=_w-_downBtn.width;
			_downBtn.addEventListener(MouseEvent.CLICK, btnMouseHandler);
			_downBtn.addEventListener(MouseEvent.MOUSE_DOWN, btnMouseHandler);
			_downBtn.addEventListener(MouseEvent.MOUSE_UP, btnMouseHandler);
			_downBtn.addEventListener(MouseEvent.MOUSE_OUT, btnMouseHandler);
		}

		public function get downBtn():InteractiveObject
		{
			return _downBtn;
		}

		/**
		 * 垂直拖动按钮
		 * 
		 * 如果希望可以进行不变形拉伸，请在 mc 中放置：
		 * mc.bg —— 可伸展的背景（需设置了 scale9Grid 范围）
		 * mc.icon —— 拖动条上不会拉伸的可爱图标（可选）
		 * @param mc
		 *
		 */
		public function set dragBtnV(mc:InteractiveObject):void
		{
			_dragBtnV=mc;
//			_dragBtnV.x=_w-trackV.width+(trackV.width-_dragBtnV.width)/2;
			_dragBtnV.y=upBtn.height;
			_dragBtnV.addEventListener(MouseEvent.MOUSE_DOWN, dragBtnVMouseHandler);
			_dragBtnV.addEventListener(MouseEvent.MOUSE_UP, dragBtnVMouseHandler);
			
			if (dragBtnV.hasOwnProperty("icon"))
			{
				var dis:DisplayObject=dragBtnV["icon"];
				
				if(dis is InteractiveObject){
					InteractiveObject(dis).mouseEnabled=false;
				}
				
				if(dis is DisplayObjectContainer){
					DisplayObjectContainer(dis).mouseChildren=false;
				}
			}
		}

		public function get dragBtnV():InteractiveObject
		{
			return _dragBtnV;
		}

		/**
		 * 设置垂直拖动条的最小高度
		 * 
		 * 未设值则取皮肤默认高度【高度永远保持不变】
		 * 设小于5则取5【随内容高度自动变化 但最小5个像素，因为人眼总有极限嘛，你知道的】
		 * 设其它值则取其它值
		 * @param n
		 */
		public function set dragBtnVMin(n:Number):void
		{
			if(n>trackVH){
				n=trackVH
			}
			_dragBtnVMin=n;
			doChange();
		}

		public function get dragBtnVMin():Number
		{
			return _dragBtnVMin;
		}

		/**
		 * 设置垂直拖动条的最大高度
		 * 
		 * 未设值则取皮肤默认高度【高度永远保持不变】
		 * 设0则自动填充【随内容高度自动变化】
		 * 设其它值则取其它值
		 * 最大为拖动轨道高度减去上下按钮高度
		 * @param n
		 * 
		 */
		public function set dragBtnVMax(n:Number):void
		{
			if(n>trackVH){
				n=trackVH
			}
			_dragBtnVMax=n;
			doChange();
		}

		public function get dragBtnVMax():Number
		{
			return _dragBtnVMax;
		}

		/**
		 * 设置点击“垂直滚动按钮”时每次滚动多少像素
		 * @param mc
		 *
		 */
		public function set rollNumV(n:Number):void
		{
			_rollNumV=n;
		}

		public function get rollNumV():Number
		{
			return _rollNumV;
		}

		/**
		 * 设置鼠标 down 时自动滚动的数值（垂直方向）
		 * @param mc
		 *
		 */
		public function set autoRollNumV(n:Number):void
		{
			_autoRollNumV=n;
		}

		public function get autoRollNumV():Number
		{
			return _autoRollNumV;
		}

		/**
		 * 设置垂直滚动条显示模式
		 * 
		 * 可以传的参数：
		 * "ScrollBar_Show_Mode_auto"
		 * "ScrollBar_Show_Mode_hide"
		 * "ScrollBar_Show_Mode_show"
		 * @param b
		 *
		 */
		public function set vScrollBarShowMode(b:String):void
		{
			_VScrollBarShowMode=b;
		}

		public function get vScrollBarShowMode():String
		{
			return _VScrollBarShowMode;
		}
		
		/**
		 * 复位垂直滚动条(回到0位置)
		 * 
		 */
		public function initVBar():void
		{
			_target.y=0;
			doChange();
		}

		/**
		 * 更新所有滚动条
		 *
		 */
		public function doChange():void
		{
			checkScrollShowMode();
			
			if(_target.y>0){
				_target.y=0;
			}
			
			if (_scrollBarVSkin.visible == true)
			{
				updateDragBtnV();

				if (_target.height <= _h)
				{
//					_target.x=0;
					_target.y=0;
					topVScrollBar();
				}
				else
				{
					changeV();
				}
			}else{
				_target.y=0;
			}
		}

		/**
		 * 更新垂直拖动按钮的高度
		 *
		 */
		private function updateDragBtnV():void
		{
			if (_target.height <= _h)
			{
				if (isNaN(dragBtnVMax)) //未设值取皮肤默认高度（高度永远保持不变）
				{

				}
				else if (dragBtnVMax == 0) //设0则自动填充（随内容高度自动变化）
				{
					setDragBtnVH(trackVH);
				}
				else //设其它值则取其它值
				{
					var len:Number=Math.abs(dragBtnVMax);
					if (len < 5)
					{
						len=5;
					}
					setDragBtnVH(len);
				}
			}
			else
			{

				if (isNaN(dragBtnVMin)) //未设值取皮肤默认高度（高度永远保持不变）
				{

				}
				else if (dragBtnVMin < 5) //设小于5则取5【随内容高度自动变化 但最小5个像素，因为人眼总有极限嘛，你知道的】
				{
					var percent:Number=(_target.height - _h) / _target.height;
					var len2:Number=trackVH * percent;
					if (len2 < 5)
					{
						len2=5;
					}
					setDragBtnVH(len2);
				}
				else //设其它值则取其它值
				{
					setDragBtnVH(Math.abs(dragBtnVMin));
				}
			}
		}
		
		/**
		 * 垂直滑轨当前实际可拖动范围（减去上、下两个按钮的高度后）
		 * @return 
		 * 
		 */
		private function get trackVH():Number
		{
			var n:Number=_trackVHMin;
			
			if(_scrollBarVSkin!=null && upBtn!=null && downBtn!=null){
				n=_scrollBarVSkin.height - (upBtn.height + upBtn.y) - (_h - downBtn.y)
			}
			
			return n;
		}

		/**
		 * 设置垂直拖动按钮高度
		 * @param n
		 *
		 */
		private function setDragBtnVH(n:Number):void
		{
			if (dragBtnV.hasOwnProperty("bg"))
			{
				dragBtnV["bg"].height=n;
			}
			else
			{
				dragBtnV.height=n;
			}

			if (dragBtnV.hasOwnProperty("icon"))
			{
				dragBtnV["icon"].y=(dragBtnV["bg"].height - dragBtnV["icon"].height) / 2;
			}
		}

		/**
		 * 更新垂直方向滚动条
		 *
		 */
		private function changeV():void
		{
			var len:Number=_target.height - _h;
			var percent:Number;
			
			if(len<0){
				percent=0;
			}else{
				percent=-_target.y / len;
			}
			
			if(percent<0){
				percent=0;
			}
			
			changeScrollV(percent);
		}

		/**
		 * 根据拖动目标 Y 值的百分比设置滚动条 Y 位置
		 * @param percent
		 *
		 */
		private function changeScrollV(percent:Number):void
		{
			var pos:Number=(trackVH - dragBtnV.height) * percent;
			dragBtnV.y=upBtn.height + pos;
		}

		/**
		 * 垂直滚动条-居顶
		 *
		 */
		private function topVScrollBar():void
		{
			dragBtnV.y=upBtn.height;
		}

//		/**
//		 * 垂直滚动条-居中
//		 *
//		 */
//		private function centerVScrollBar():void
//		{
//			dragBtnV.y=trackV.height / 2 - dragBtnV.height / 2;
//		}
//
//		/**
//		 * 垂直滚动条-居底
//		 *
//		 */
//		private function bottomVScrollBar():void
//		{
//			dragBtnV.y=downBtn.y - dragBtnV.height;
//		}
		
		override public function set visible(value:Boolean):void
		{
			checkScrollShowMode();
			super.visible = value;
		}

		/**
		 * 检查、调整滚动条显示状态
		 *
		 */
		private function checkScrollShowMode():void
		{
			switch (vScrollBarShowMode) //检查垂直滚动条显示状态
			{
				case SCROLLBAR_SHOW_MODE_AUTO:
					_scrollBarVSkin.visible=_target.height < _h ? false : true;
					break;
				case SCROLLBAR_SHOW_MODE_SHOW:
					_scrollBarVSkin.visible=true;
					break;
				case SCROLLBAR_SHOW_MODE_HIDE:
					_scrollBarVSkin.visible=false;
					break;
			}
			
			//如果垂直滚动条不显示了，且物体宽度小于滚动面板宽度，则让物体x坐标居中
			if(_scrollBarVSkin.visible==false && _target.width<_w)
			{
//				_target.x=(_w-_target.width)/2;
				_target.x=0;
			}
			else
			{
				_target.x=0;
			}
		}

		/**
		 * 拖动按钮鼠标事件处理
		 * @param e
		 *
		 */
		private function dragBtnVMouseHandler(e:MouseEvent):void
		{
			switch (e.type)
			{
				case MouseEvent.MOUSE_DOWN:
					if (e.currentTarget == dragBtnV)
					{
						trackV.removeEventListener(MouseEvent.CLICK, trackMouseHandler);
						trackV.removeEventListener(MouseEvent.MOUSE_DOWN, trackMouseHandler);
						trackV.removeEventListener(MouseEvent.MOUSE_UP, trackMouseHandler);
						trackV.removeEventListener(MouseEvent.MOUSE_OUT, trackMouseHandler);
						removeAutoRollTimeOut();

						if (stage)
						{
							stage.focus=e.currentTarget as InteractiveObject;
							stage.addEventListener(MouseEvent.MOUSE_MOVE, startDragV);
							stage.addEventListener(MouseEvent.MOUSE_UP, stopDragV);
							stage.addEventListener(Event.MOUSE_LEAVE, stopDragV2);
						}
					}
					break;
				case MouseEvent.MOUSE_UP:
					stopDragV(null);
					break;
			}
		}

		private function startDragV(e:MouseEvent):void
		{
			dragBtnV.y=mouseY - dragBtnV.height / 2;

			if (dragBtnV.y < upBtn.height)
			{
				dragBtnV.y=upBtn.height;
			}
			else if (dragBtnV.y > downBtn.y - dragBtnV.height)
			{
				dragBtnV.y=downBtn.y - dragBtnV.height;
			}

			/**
			 * 垂直滑轨当前实际可拖动范围（减去上、下、拖动三个按钮的高度后）
			 */
			var trackVH$:Number=trackVH - dragBtnV.height;
			var percent:Number=(dragBtnV.y - upBtn.height) / trackVH$;
			changeTargetV(percent);
		}

		/**
		 * 根据拖动条 Y 位置调整拖动目标的 Y 位置
		 * @param percent
		 *
		 */
		private function changeTargetV(percent:Number):void
		{
			var len:Number=_target.height - _h;
			if (len < 0)
			{
				_target.y=0;
			}
			else
			{
				_target.y=-len * percent;
				if (-_target.y > len)
				{
					_target.y=-len
				}
			}
		}

		private function stopDragV2(e:Event):void
		{
			stopDragV(null);
		}

		private function stopDragV(e:MouseEvent):void
		{
			if (stage)
			{
				stage.removeEventListener(MouseEvent.MOUSE_MOVE, startDragV);
				stage.removeEventListener(MouseEvent.MOUSE_UP, stopDragV);
				stage.removeEventListener(Event.MOUSE_LEAVE, stopDragV2);
			}

			trackV.addEventListener(MouseEvent.CLICK, trackMouseHandler);
			trackV.addEventListener(MouseEvent.MOUSE_DOWN, trackMouseHandler);
			trackV.addEventListener(MouseEvent.MOUSE_UP, trackMouseHandler);
			trackV.addEventListener(MouseEvent.MOUSE_OUT, trackMouseHandler);
		}

		/**
		 * 滑动轨道鼠标事件处理
		 * @param e
		 *
		 */
		private function trackMouseHandler(e:MouseEvent):void
		{
			switch (e.type)
			{
				case MouseEvent.CLICK:
					if (e.currentTarget == trackV)
					{
						if(stage){
							stage.focus = trackV;
						}
						if (this.mouseY > dragBtnV.y)
						{
							doDown(rollNumV);
						}
						else
						{
							doUP(rollNumV);
						}
					}
					break;
				case MouseEvent.MOUSE_DOWN:
					if (e.currentTarget == trackV)
					{
						if (this.mouseY > dragBtnV.y)
						{
							_autoRollIntervalID=setTimeout(startEnterFrameV_DOWN, _autoRollTime);
						}
						else
						{
							_autoRollIntervalID=setTimeout(startEnterFrameV_UP, _autoRollTime);
						}
					}
					break;
				case MouseEvent.MOUSE_UP:
				case MouseEvent.MOUSE_OUT:
					removeAutoRollTimeOut();
					break;
			}
		}

		/**
		 * 上、下、左、右滚动按钮鼠标事件处理
		 * @param e
		 *
		 */
		private function btnMouseHandler(e:MouseEvent):void
		{
			switch (e.type)
			{
				case MouseEvent.CLICK:
					switch (e.currentTarget)
				{
					case upBtn:
						doUP(rollNumV);
						break;
					case downBtn:
						doDown(rollNumV);
						break;
				}
					break;
				case MouseEvent.MOUSE_DOWN:
					switch (e.currentTarget)
				{
					case upBtn:
						_autoRollIntervalID=setTimeout(startEnterFrameV_UP, _autoRollTime);
						break;
					case downBtn:
						_autoRollIntervalID=setTimeout(startEnterFrameV_DOWN, _autoRollTime);
						break;
				}
					break;
				case MouseEvent.MOUSE_UP:
				case MouseEvent.MOUSE_OUT:
					removeAutoRollTimeOut();
					break;
			}
		}

		private function startEnterFrameV_UP():void
		{
			trackV.removeEventListener(MouseEvent.CLICK, trackMouseHandler);
			upBtn.removeEventListener(MouseEvent.CLICK, btnMouseHandler);

			if (stage)
			{
				stage.addEventListener(Event.ENTER_FRAME, onEnterFrameV_UP);
			}
		}

		private function startEnterFrameV_DOWN():void
		{
			trackV.removeEventListener(MouseEvent.CLICK, trackMouseHandler);
			downBtn.removeEventListener(MouseEvent.CLICK, btnMouseHandler);

			if (stage)
			{
				stage.addEventListener(Event.ENTER_FRAME, onEnterFrameV_DOWN);
			}
		}

		private function onEnterFrameV_UP(e:Event):void
		{
			doUP(autoRollNumV);
		}

		private function onEnterFrameV_DOWN(e:Event):void
		{
			doDown(autoRollNumV);
		}

		/**
		 * 当 Scrollpane 被添加到舞台中
		 * @param e
		 *
		 */
		private function onAddToStage(e:Event):void
		{
			stage.stageFocusRect=false;
			this.focusRect=false;
			stage.addEventListener(MouseEvent.MOUSE_WHEEL, onMouseWheel);
		}

		/**
		 * 当 Scrollpane 从舞台中移除
		 * @param e
		 *
		 */
		private function onRemoveFromStage(e:Event):void
		{
			stage.removeEventListener(MouseEvent.MOUSE_WHEEL, onMouseWheel);
		}
		
		/**
		 * 设置舞台焦点-辅助实现鼠标滚轮滚动
		 * @param e
		 * 
		 */
		private function onTargetContainerClick(e:MouseEvent):void
		{
			if (stage)
			{
				stage.focus=e.currentTarget as InteractiveObject;
			}
		}

		/**
		 * 鼠标滚轮事件
		 * @param e
		 *
		 */
		private function onMouseWheel(e:MouseEvent):void
		{
			if (stage.focus == _targetContainer || stage.focus == upBtn || stage.focus == downBtn || stage.focus == trackV || stage.focus == dragBtnV)
			{
				if (e.delta > 0)
				{
					//滚动条向上滚动
					doUP(rollNumV);
				}
				else
				{
					//滚动条向下滚动
					doDown(rollNumV);
				}
			}
		}

		/**
		 * 停止自动滚动
		 *
		 */
		private function removeAutoRollTimeOut():void
		{
			clearTimeout(_autoRollIntervalID);

			if (stage)
			{
				stage.removeEventListener(Event.ENTER_FRAME, onEnterFrameV_UP);
				stage.removeEventListener(Event.ENTER_FRAME, onEnterFrameV_DOWN);
			}

			start_Click_Listener_V();
		}

		/**
		 * 恢复 click 监听（垂直滚动条的上下滚动按钮）
		 *
		 */
		private function start_Click_Listener_V():void
		{
			upBtn.addEventListener(MouseEvent.CLICK, btnMouseHandler);
			downBtn.addEventListener(MouseEvent.CLICK, btnMouseHandler);
			trackV.addEventListener(MouseEvent.CLICK, trackMouseHandler);
		}


		/**
		 * 滚动条向上滚动（目标向下滚动）
		 * @param num 滚动数值
		 *
		 */
		private function doUP(num:Number):void
		{
			if (_target.height > _h) //判断滚动对象是否比显示框高
			{
				if (_target.y < 0)
				{
					if (-_target.y > num)
					{
						_target.y+=num;
					}
					else
					{
						_target.y=0;
					}
				}
			}
			doChange();
		}

		/**
		 * 滚动条向下滚动（目标向上滚动）
		 * @param num 滚动数值
		 *
		 */
		private function doDown(num:Number):void
		{
			if (_target.height > _h) //判断滚动对象是否比显示框高
			{
				if (_target.height + _target.y > _h)
				{
					if (_target.height + _target.y - _h > num)
					{
						_target.y-=num;
					}
					else
					{
						_target.y=_h - _target.height;
					}
				}
			}
			doChange();
		}
		
		private function removeTarget():void
		{
			if(_target){
				if(_target.parent){
					try{
						_target.parent.removeChild(_target);
					}catch(e:*){}
				}
				_target=null;
			}
		}
		
		public function removeAll():void
		{
			removeTarget();
			
			if(stage){
				stage.removeEventListener(Event.ENTER_FRAME, onEnterFrameV_UP);
				stage.removeEventListener(Event.ENTER_FRAME, onEnterFrameV_DOWN);
				stage.removeEventListener(MouseEvent.MOUSE_WHEEL, onMouseWheel);
				stage.removeEventListener(MouseEvent.MOUSE_MOVE, startDragV);
				stage.removeEventListener(MouseEvent.MOUSE_UP, stopDragV);
				stage.removeEventListener(Event.MOUSE_LEAVE, stopDragV2);
			}
			
			this.addEventListener(Event.ADDED_TO_STAGE, onAddToStage);
			this.addEventListener(Event.REMOVED_FROM_STAGE, onRemoveFromStage);
		}

	}
}

/********************************************************************************
 *
 *
 *
   使用实例：

   var s:Sprite=new Sprite;
   s.graphics.beginFill(0x545454);
   s.graphics.drawRect(0,0,200,700);

   var sp:ScrollPane_SM=new ScrollPane_SM(s,300,300,30);
   addChild(sp);
	
 * 
 *	注意：当滚动内容尺寸发生变化时记得执行 sp.doChange();
 * 
 * 
 *
 ********************************************************************************/